home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / apps / database / postgres / postgre4.z / postgre4 / src / contrib / 3M / pg_exec.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-08-27  |  10.7 KB  |  388 lines
  1. #include "tmp/libpq.h"
  2. #include <stdio.h>
  3.  
  4. #define LL 1000        /* upper limit on length of a data line */
  5. #define VPL '{'        /* left hand side of a var in template */
  6. #define VPR '}'         /* right hand side of var in template */ 
  7. #define MAX_COL 99      /* max number of columns per data line 
  8.                            if MAX_COL is larger than 99, fix code in 
  9.                            pg_process_data_file to handle more than 2 digits */ 
  10. #define NULL_CHAR '&'
  11.  
  12.  
  13. /**********************************************************************
  14.   $Header: /private/postgres/src/contrib/3M/RCS/pg_exec.c,v 1.3 1991/05/15 08:37:17 mao Exp $
  15.  **********************************************************************
  16.  FILE: pg_exec.c
  17.        pg_exec [-c | -d] databasename filename
  18.  
  19.        Author:  Steve Anastasi, 3M, 612-733-6970
  20.                 smanastasi@mmm.serc.3m.com
  21.  
  22.        
  23.  
  24.        Date: 6-29-90
  25.  
  26.        Processes ascii files as postgres commands.  This program takes
  27.        a two arguments - a database name, and a filename or pathname
  28.        of an ascii file.  The database must already exist.
  29.        Two options are available:
  30.  
  31.          -c  Process the ascii file as a sequence of postgres
  32.          commands.  This is the default.  See the format of a
  33.          postgres command file below.
  34.  
  35.          -d  Process the ascii file as data file.  Data in the file is
  36.          imported according to a specification contained on the
  37.          first line of the file.  See the format of a import file
  38.          below. 
  39.  
  40.        Command file format:
  41.        --------------------
  42.        Each line is simply a postgres command that can be executed
  43.        directly using PQexec.  Using pg_exec -c <filename> has the
  44.        same effect as using the terminal monitor interface and
  45.        including the filename (\i filename).  
  46.  
  47.        It is important that each postgres command is entirely
  48.        contained on a single line and the each line is deliminated by
  49.        a newline or return character.
  50.  
  51.        Import file format:
  52.        -------------------
  53.        An import file is composed of two sections.  The first section
  54.        is the first line of the file.  It specifies the postgres
  55.        command that should be used to add the data to the database.
  56.        This is called the command template.
  57.  
  58.        The second section is the rest of the file.  Each line is a
  59.        tab-deliminated record containing data.  Special tokens ({num})
  60.        in the command template specify the column of data that should be
  61.        used.  An example follows.
  62.  
  63.        append somerel (name={0}::text, id={1}, gpa={2}::float4)
  64.        "David Byrne"  154323  "3.00"
  65.        "Phillip E. Bach"      000321  "3.93"
  66.        "Ronald Reagan"        000000  "0.00"
  67.        "Cole Porter"  103423  "2.45"
  68.  
  69.        Note that each field is tab-delimited and each value must be in
  70.        the proper syntax so it can be dropped right in for its {#}.
  71.  
  72.        In addition, no null values can be specified in a dataline by
  73.        \tab\tab or any other trick.  For example, if {7} is the
  74.        largest number (7) in the command template, then there must be
  75.        8 values (0,1,2,...,7) on every line of data.
  76. */
  77.  
  78.  
  79. /**********************************************************************
  80.    pqexec_ret
  81.  
  82.    Looks at first character of the string returned by pqexec.  If
  83.    there is an error, -1 is returned, else 1 is returned.
  84.    */
  85. int pqexec_ret (s)
  86.   char *s;
  87. {
  88.   if (s[0] == 'R')
  89.     return(-1);
  90.   else
  91.     return(1);
  92. }
  93.  
  94.  
  95.  
  96.  
  97.  
  98. /**********************************************************************
  99.    Read a text string from an ascii file.  A text string is defined as
  100.    text deliminated by either a tab, newline or return character.
  101.    In the process of reading a string, the file pointer gets advanced.
  102.    Note that spaces do not deliminate strings.
  103.    */
  104.  
  105. void get_string(fptr, string_buffer)
  106.   FILE *fptr;
  107.   char *string_buffer;
  108. {
  109.   int i;
  110.  
  111.   i = 0;
  112.   if ((string_buffer[i] = getc(fptr)) != EOF) {
  113.     while (string_buffer[i] != EOF &&
  114.            string_buffer[i] != '\t' &&
  115.            string_buffer[i] != '\n' &&
  116.            string_buffer[i] != '\r') {
  117.       i = i+1;
  118.       string_buffer[i] = getc(fptr);
  119.     }
  120.   }    
  121.   /* Now replace the last character with a null terminater */
  122.   string_buffer[i] = '\0';
  123. } 
  124.  
  125.  
  126. /**********************************************************************
  127.    Read a line from a text file.  A line is defined as any character
  128.    string that ends in \n .  Returns a ptr to a null terminated string
  129.  
  130.    NOT CURRENTLY USED.  USE GET_STRING INSTEAD IF POSSIBLE
  131.    */
  132.    
  133. char * readline(fptr)
  134.   FILE *fptr;
  135. {
  136.   char buffer[LL];
  137.   int i;
  138.  
  139.   i = 0;
  140.   buffer[i] = getc(fptr);
  141.   while (buffer[i] != EOF && buffer[i] != '\n')
  142.     buffer[++i] = getc(fptr);
  143.   buffer[i] = '\0';
  144.   return(buffer);
  145. }
  146.  
  147.   
  148. /*********************************************************************
  149.    pg_process_data_file 
  150.  
  151.    Reads formatted data from a ascii file and inserts the data into
  152.    a postgres relation.  One file can contain data for only one
  153.    relation.  
  154.  
  155.    File Format:
  156.    The first line is a template to be used to specify how the data
  157.    will get append to a relation.  The token VPL and VPR  indicates a place
  158.    to drop in data from the data file.  In each VP is a number
  159.    indicating what field from a data line to use.  (See top of file
  160.    for definition of VPL and VPR.)
  161.  
  162.    Example:
  163.    A datafile might look like:
  164.  
  165.    append parameter (name={0}::text, age={1}, weight={2}::float4)
  166.    Steve Anastasi     26     190.04
  167.    Saavik Stargazer     1     67.30
  168.    etc.,
  169.  
  170.    Note that each field is tab delimited and each line ends in a newline
  171.    or return character.
  172.  
  173.    Limitations:  At most, MAX_COL data columns can be handled
  174.                  Every column in the data file must have a value 
  175.    */
  176.  
  177.  
  178. void pg_process_data_file(fptr)
  179.   FILE *fptr;
  180.  
  181. {
  182.   char header[LL], command_string[LL*2], data[LL], tc;
  183.   char var_num[3], tk[MAX_COL][LL];
  184.   int i, h_ctr, c_ctr, token_count, var_val, EOF_REACHED;
  185.  
  186.   EOF_REACHED = 0;
  187.   get_string(fptr, header);
  188.   /* Find out how many data fields should be on each data line.  This
  189.      is done by finding the maximum number enclosed in VPL and VPR. 
  190.      The number of data fields is this number plus 1 (since counting
  191.      starts at 0. */
  192.   token_count = 0;
  193.   i = 0;
  194.   while (header[i] != '\0')  {
  195.     if (header[i] == VPL) {
  196.       /* see if there is one or two digits after VPL */
  197.       if (header[i+2] == VPR) {  /* one digit */
  198.         var_num[0] = '0';
  199.         var_num[1] = header[i+1];
  200.         var_num[2] = '\0';
  201.       }
  202.       else if (header[i+3] == VPR) { /* 2 digits */
  203.         var_num[0] = header[i+1];
  204.         var_num[1] = header[i+2];
  205.         var_num[2] = '\0';
  206.       }
  207.       else { /* problem */
  208.         printf("Error in data file.  Unknown {  } syntax\n");
  209.         abort();
  210.       }
  211.       sscanf(var_num, "%d", &var_val);
  212.       if (var_val > token_count)
  213.         token_count = var_val;
  214.     }
  215.     i = i+1;
  216.   }
  217.  
  218.   /* Iterate thru all data lines */
  219.   while (!EOF_REACHED) {
  220.     /* Now get as many strings from the data file as specified by
  221.        token count */
  222.     for (i=0;i<=token_count;i++) {
  223.       get_string(fptr, tk[i]);
  224.       if (tk[i][0] == '\0') 
  225.     EOF_REACHED = 1;
  226.     }
  227.  
  228.     /* Now start to copy header into command_string, and replace
  229.        {x} with tk[x] */
  230.     h_ctr = 0;
  231.     c_ctr = 0;
  232.     while (header[h_ctr] != '\0' && c_ctr < LL*2 && !EOF_REACHED) {
  233.       /* printf("H[%d]: %c\nC: %s\n",h_ctr,header[h_ctr],command_string); */
  234.       if (header[h_ctr] == VPL) {
  235.         /* see if there is one or two digits after VPL */
  236.         if (header[h_ctr+2] == VPR) {  /* one digit */
  237.           var_num[0] = '0';
  238.           var_num[1] = header[h_ctr+1];
  239.           var_num[2] = '\0';
  240.           h_ctr = h_ctr + 3;  /* advance to after VPR */
  241.         }
  242.         else if (header[h_ctr+3] == VPR) { /* 2 digits */
  243.           var_num[0] = header[h_ctr+1];
  244.           var_num[1] = header[h_ctr+2];
  245.           var_num[2] = '\0';
  246.           h_ctr = h_ctr + 4;  /* advance to after VPR */
  247.         }
  248.         else { /* problem */
  249.           printf("Error in data file.  Unknown {  } syntax\n");
  250.           abort();
  251.         }
  252.         sscanf(var_num, "%d", &var_val);
  253.   
  254.       /* now splice in tk[var_val] to command_string */
  255.         i = 0;
  256.         while (*(tk[var_val]+i) != '\0') {
  257.           command_string[c_ctr] = *(tk[var_val]+i);
  258.           i = i+1;
  259.           c_ctr = c_ctr+1;
  260.         }
  261.       } /* header[h_ctr] == VPL */
  262.       else { /* just copy from header to command string */
  263.         command_string[c_ctr] = header[h_ctr];
  264.         h_ctr = h_ctr + 1;
  265.         c_ctr = c_ctr + 1;
  266.       }
  267.     }
  268.     if (!EOF_REACHED) {
  269.       /* Now execute the query */
  270.       command_string[c_ctr] = '\0';
  271.       printf("Exec: %s\n", command_string); 
  272.       if (pqexec_ret(PQexec(command_string)) < 0)
  273.         printf("*Error* %s\n", command_string);
  274.     }
  275.   } /* end while not EOF_REACHED */
  276.   printf("\n");
  277. }    
  278.   
  279.  
  280. /*******************************************************************
  281.   pg_process_command_file
  282.  
  283.   Reads a ascii file of postgres commands and executes them.  Each
  284.   command must be on a single line.
  285.   */
  286.  
  287. void pg_process_command_file(fptr)
  288.   FILE *fptr;
  289.  
  290. {
  291.   char command[255];
  292.   int EOF_REACHED;
  293.  
  294.   EOF_REACHED = 0;
  295.  
  296.   while (!EOF_REACHED) {
  297.     get_string(fptr, command);
  298.     if (command[0] == '\0') 
  299.       EOF_REACHED = 1;
  300.     else {
  301.       printf("Exec: %s\n", command); 
  302.       if (pqexec_ret(PQexec(command)) < 0)
  303.         printf("*Error* %s\n", command);
  304.     }
  305.   }
  306.   printf("\n");
  307. }
  308.  
  309.   
  310.   
  311. /******************************************************************* */
  312. main (argc, argv)
  313.   int argc;
  314.   char *argv[];
  315.  
  316. {
  317.   FILE *fopen(), *fptr;
  318.   char db_name[16],filename[80], *s, option;
  319.   int place, j, error;  /* error: -1= bad command line, -2=bad file, -3=bad */
  320.          /* db name */
  321.  
  322.   error = 0;
  323.   /* check for bad command line */
  324.   if (argc < 3)
  325.     error = -1;
  326.   else if (argc==3 && (argv[1][0] == '-' || argv[2][0] == '-'))
  327.     error = -1;
  328.   else if (argc==4 && (argv[1][0] != '-' || argv[2][0] == '-' ||
  329.               argv[3][0] == '-'))
  330.     error = -1;
  331.   else if (argc > 4)
  332.     error = -1;
  333.  
  334.   if (error == -1) {
  335.     printf("Usage: pg_exec [-c | -d] dbname filename\n");
  336.     exit(-1);
  337.   }
  338.  
  339.   /* get the option */
  340.   if (argv[1][0] == '-')
  341.     option = argv[1][1];
  342.   else
  343.     option = 'c';   /* the default */
  344.  
  345.   /* get the database */
  346.   if (argv[1][0] == '-')
  347.     place = 2;
  348.   else
  349.     place = 1;
  350.  
  351.   j = 0;
  352.   while (argv[place][j] != '\0' && j < 16) {
  353.  
  354.     db_name[j] = argv[place][j];
  355.     j = j + 1;
  356.   }
  357.  
  358.   j =0;
  359.   /* get file name */
  360.   place = place +1;
  361.   while (argv[place][j] != '\0' && j < 80) {
  362.     filename[j] = argv[place][j];
  363.     j = j + 1;
  364.   }
  365.  
  366.   
  367.   /* Now do the right thing */
  368.  
  369.   PQsetdb(db_name); 
  370.  
  371.   printf("*Database: %s\n", PQdb());
  372.  
  373.   fptr = fopen(filename, "r");;
  374.   if (fptr == (FILE *) NULL) {
  375.     printf("Had problem opening %s.\n", filename);
  376.     exit(-1);
  377.   }
  378.  
  379.   if (option == 'c')
  380.     pg_process_command_file(fptr);
  381.   else if (option == 'd')
  382.     pg_process_data_file(fptr);
  383.  
  384.   close (fptr);
  385. }
  386.  
  387.  
  388.